home *** CD-ROM | disk | FTP | other *** search
/ PsL Monthly 1993 December / PSL Monthly Shareware CD-ROM (December 1993).iso / prgmming / dos / c / timedat.exe / TIMPOINT.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1992-05-06  |  7.6 KB  |  368 lines
  1.  
  2. /*
  3.  Copyright 1992 - John K. Humkey
  4.  */
  5.  
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include <conio.h>
  9. #include <string.h>
  10. #include <dos.h>
  11. #include "timespan.h"
  12. #include "timpoint.h"
  13.  
  14. extern int __european;
  15.  
  16. void astro_to_date(int *year, int *month, int *day, long *ast);
  17. void date_to_astro(int *year, int *month, int *day, long *ast);
  18. void time_to_astro(int *hour, int *mins,  int *sec, int *millisec, long *ast);
  19. void astro_to_time(int *hour, int *mins,  int *sec, int *millisec, long *ast);
  20.  
  21. //
  22. // TIMEPOINT::OPERATOR +
  23. //
  24. //
  25. timepoint operator + ( timepoint &tdone, timespan &tdtwo )
  26. {
  27. timepoint temptd;
  28. long dx,tx;
  29.  
  30.     tx = tdone.msecval + tdtwo.msecval;
  31.     dx = tdone.dateval + tdtwo.daysval;
  32.     dx += tx / (24L * 60L * 60L * 1000L);
  33.     tx %= (24L * 60L * 60L * 1000L);
  34.     temptd.setdt(dx,tx);
  35.  
  36.     return temptd;
  37. }
  38.  
  39. //
  40. // TIMEPOINT::OPERATOR -
  41. //
  42. //
  43. timepoint operator - ( timepoint &tdone, timespan &tdtwo )
  44. {
  45. timepoint temptd, tanother;
  46. long dx,tx;
  47.  
  48.     if ( (tdone.dateval < tdtwo.daysval) ||
  49.      ((tdone.dateval == tdtwo.daysval) && (tdone.msecval < tdtwo.msecval))) {
  50.         temptd.setdt(0L,0L);
  51.     }
  52.     else {
  53.         if (tdone.msecval < tdtwo.msecval) {
  54.             tanother.dateval = tdone.dateval - 1;
  55.             tanother.msecval = tdone.msecval + (24L * 60L * 60L * 1000);
  56.         }
  57.         else {
  58.             tanother = tdone;
  59.         }
  60.         tx = tanother.msecval - tdtwo.msecval;
  61.         dx = tanother.dateval - tdtwo.daysval;
  62.         dx += tx / (24L * 60L * 60L * 1000L);
  63.         tx %= (24L * 60L * 60L * 1000L);
  64.         temptd.setdt(dx,tx);
  65.     }
  66.  
  67.     return temptd;
  68. }
  69.  
  70. //
  71. // TIMEPOINT::OPERATOR -
  72. //
  73. //
  74. timespan operator - ( timepoint &tdone, timepoint &tdtwo )
  75. {
  76. timespan temptd;
  77. timepoint tanother;
  78. long dx,tx;
  79.  
  80.     if ( (tdone.dateval < tdtwo.dateval) ||
  81.      ((tdone.dateval == tdtwo.dateval) && (tdone.msecval < tdtwo.msecval))) {
  82.         temptd.setdt(0L,0L);
  83.     }
  84.     else {
  85.         if (tdone.msecval < tdtwo.msecval) {
  86.             tanother.dateval = tdone.dateval - 1;
  87.             tanother.msecval = tdone.msecval + (24L * 60L * 60L * 1000);
  88.         }
  89.         else {
  90.             tanother = tdone;
  91.         }
  92.         tx = tanother.msecval - tdtwo.msecval;
  93.         dx = tanother.dateval - tdtwo.dateval;
  94.         dx += tx / (24L * 60L * 60L * 1000L);
  95.         tx %= (24L * 60L * 60L * 1000L);
  96.         temptd.setdt(dx,tx);
  97.     }
  98.  
  99.     return temptd;
  100. }
  101.  
  102. //
  103. // TIMEPOINT::OPERATOR +=
  104. //
  105. //
  106. timepoint operator += ( timepoint &tdone, timespan &tdtwo )
  107. {
  108. long dx,tx;
  109.  
  110.     tx = tdone.msecval + tdtwo.msecval;
  111.     dx = tdone.dateval + tdtwo.daysval;
  112.     dx += tx / (24L * 60L * 60L * 1000L);
  113.     tx %= (24L * 60L * 60L * 1000L);
  114.     tdone.setdt(dx,tx);
  115.  
  116.     return tdone;
  117. }
  118.  
  119. //
  120. // TIMEPOINT::OPERATOR -=
  121. //
  122. //
  123. timepoint operator -= ( timepoint &tdone, timespan &tdtwo )
  124. {
  125. timepoint tanother;
  126. long dx,tx;
  127.  
  128.     if ( (tdone.dateval < tdtwo.daysval) ||
  129.      ((tdone.dateval == tdtwo.daysval) && (tdone.msecval < tdtwo.msecval))) {
  130.         tdone.setdt(0L,0L);
  131.     }
  132.     else {
  133.         if (tdone.msecval < tdtwo.msecval) {
  134.             tanother.dateval = tdone.dateval - 1;
  135.             tanother.msecval = tdone.msecval + (24L * 60L * 60L * 1000);
  136.         }
  137.         else {
  138.             tanother = tdone;
  139.         }
  140.         tx = tanother.msecval - tdtwo.msecval;
  141.         dx = tanother.dateval - tdtwo.daysval;
  142.         dx += tx / (24L * 60L * 60L * 1000L);
  143.         tx %= (24L * 60L * 60L * 1000L);
  144.         tdone.setdt(dx,tx);
  145.     }
  146.  
  147.     return tdone;
  148. }
  149.  
  150. //
  151. // TIMEPOINT::OPERATOR <
  152. //
  153. //
  154. int      operator < ( timepoint &tdone, timepoint &tdtwo )
  155. {
  156.     if ( (tdone.dateval < tdtwo.dateval) ||
  157.           ((tdone.dateval == tdtwo.dateval) && (tdone.msecval < tdtwo.msecval)))
  158.         return 1;
  159.     else
  160.         return 0;
  161. }
  162.  
  163. //
  164. // TIMEPOINT::OPERATOR >
  165. //
  166. //
  167. int      operator > ( timepoint &tdone, timepoint &tdtwo )
  168. {
  169.     if ( (tdone.dateval > tdtwo.dateval) ||
  170.           ((tdone.dateval == tdtwo.dateval) && (tdone.msecval > tdtwo.msecval)))
  171.         return 1;
  172.     else
  173.         return 0;
  174. }
  175.  
  176. //
  177. // TIMEPOINT::OPERATOR ==
  178. //
  179. //
  180. int      operator == ( timepoint &tdone, timepoint &tdtwo )
  181. {
  182.     if ( (tdone.dateval == tdtwo.dateval) &&
  183.           (tdone.msecval == tdtwo.msecval) )
  184.         return 1;
  185.     else
  186.         return 0;
  187. }
  188.  
  189. //
  190. // TIMEPOINT::OPERATOR !=
  191. //
  192. //
  193. int      operator != ( timepoint &tdone, timepoint &tdtwo )
  194. {
  195.     if ( (tdone.dateval != tdtwo.dateval) ||
  196.           (tdone.msecval != tdtwo.msecval) )
  197.         return 1;
  198.     else
  199.         return 0;
  200. }
  201.  
  202. //
  203. // TIMEPOINT::OPERATOR <=
  204. //
  205. //
  206. int      operator <= ( timepoint &tdone, timepoint &tdtwo )
  207. {
  208.   if (((tdone.dateval == tdtwo.dateval) &&
  209.           (tdone.msecval == tdtwo.msecval) ) ||
  210.         ((tdone.dateval < tdtwo.dateval) ||
  211.          ((tdone.dateval == tdtwo.dateval) && (tdone.msecval < tdtwo.msecval))))
  212.         return 1;
  213.     else
  214.         return 0;
  215. }
  216.  
  217. //
  218. // TIMEPOINT::OPERATOR >=
  219. //
  220. //
  221. int      operator >= ( timepoint &tdone, timepoint &tdtwo )
  222. {
  223.   if (((tdone.dateval == tdtwo.dateval) &&
  224.          (tdone.msecval == tdtwo.msecval) ) ||
  225.         ((tdone.dateval > tdtwo.dateval) ||
  226.          ((tdone.dateval == tdtwo.dateval) && (tdone.msecval > tdtwo.msecval))))
  227.         return 1;
  228.     else
  229.         return 0;
  230. }
  231.  
  232. //
  233. // TIMEPOINT::TIMEPOINT
  234. //
  235. //
  236. timepoint::timepoint(int year, int month,  int day,
  237.                          int hour, int minute, int second,
  238.                          int millisecond)
  239. {
  240.     date_to_astro(&year,&month,&day,&dateval);
  241.     time_to_astro(&hour,&minute,&second,&millisecond,&msecval);
  242. }
  243.  
  244. //
  245. // TIMEPOINT::~TIMEPOINT
  246. //
  247. // Destructor, waits for keypress on screen, closes files for other modes.
  248. //
  249. timepoint::~timepoint()
  250. {
  251. }
  252.  
  253. //
  254. // TIMEPOINT::PRINT
  255. //
  256. // Prints internal values of a timepoint variable.
  257. //
  258. void timepoint::print()
  259. {
  260. int year, month, day, hour, mins, sec, millisec;
  261.  
  262.     astro_to_date(&year,&month,&day,&dateval);
  263.     astro_to_time(&hour,&mins,&sec,&millisec,&msecval);
  264.     printf("%04d/%02d/%02d %02d:%02d:%02d.%d\n",
  265.          year,month,day,hour,mins,sec,millisec);
  266. }
  267.  
  268. //
  269. // TIMEPOINT::MDY2W
  270. //
  271. // Prints internal values of a timepoint variable.
  272. //
  273. char* timepoint::mdy2w(char *str)
  274. {
  275. int year, month, day;
  276.  
  277.     astro_to_date(&year,&month,&day,&dateval);
  278.     if (__european)  sprintf(str,"%02d/%02d/%02d",day,month,year%100);
  279.     else             sprintf(str,"%02d/%02d/%02d",month,day,year%100);
  280.     return( str );
  281. }
  282.  
  283. //
  284. // TIMEPOINT::MDY4W
  285. //
  286. // Prints internal values of a timepoint variable.
  287. //
  288. char* timepoint::mdy4w(char *str)
  289. {
  290. int year, month, day;
  291.  
  292.     astro_to_date(&year,&month,&day,&dateval);
  293.     if (__european)  sprintf(str,"%02d/%02d/%04d",day,month,year);
  294.     else             sprintf(str,"%02d/%02d/%04d",month,day,year);
  295.     return( str );
  296. }
  297.  
  298. //
  299. // TIMEPOINT::MDY2
  300. //
  301. // Prints internal values of a timepoint variable.
  302. //
  303. char* timepoint::mdy2(char *str)
  304. {
  305. int year, month, day;
  306.  
  307.     astro_to_date(&year,&month,&day,&dateval);
  308.     if (__european)  sprintf(str,"%02d%02d%02d",day,month,year%100);
  309.     else             sprintf(str,"%02d%02d%02d",month,day,year%100);
  310.     return( str );
  311. }
  312.  
  313. //
  314. // TIMEPOINT::MDY4
  315. //
  316. // Prints internal values of a timepoint variable.
  317. //
  318. char* timepoint::mdy4(char *str)
  319. {
  320. int year, month, day;
  321.  
  322.     astro_to_date(&year,&month,&day,&dateval);
  323.     if (__european)  sprintf(str,"%02d%02d%04d",day,month,year);
  324.     else             sprintf(str,"%02d%02d%04d",month,day,year);
  325.     return( str );
  326. }
  327.  
  328. //
  329. // TIMEPOINT::Y2MD
  330. //
  331. // Prints internal values of a timepoint variable.
  332. //
  333. char* timepoint::y2md(char *str)
  334. {
  335. int year, month, day;
  336.  
  337.     astro_to_date(&year,&month,&day,&dateval);
  338.     sprintf(str,"%02d%02d%02d",year%100,month,day);
  339.     return( str );
  340. }
  341.  
  342. //
  343. // TIMEPOINT::Y4MD
  344. //
  345. // Prints internal values of a timepoint variable.
  346. //
  347. char* timepoint::y4md(char *str)
  348. {
  349. int year, month, day;
  350.  
  351.     astro_to_date(&year,&month,&day,&dateval);
  352.     sprintf(str,"%04d%02d%02d",year,month,day);
  353.     return( str );
  354. }
  355.  
  356. //
  357. // TIMEPOINT::SETDT
  358. //
  359. // Sets internal values of a timepoint variable.
  360. //
  361. void timepoint::setdt(long dx, long tx)
  362. {
  363.     dateval = dx;
  364.     msecval = tx;
  365. }
  366.  
  367.  
  368.